#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <functional>
#include <memory> // 用于智能指针

// 事件类，用于传递事件类型和事件源信息
class Event {
public:
    std::string type;  // 事件类型
    void* source;      // 事件源

    Event(std::string t, void* s) : type(t), source(s) {}
};

// 抽象观察者接口，定义了观察者的行为
class Observer {
public:
    virtual void update(Event* event) = 0;  // 更新函数，接收事件
    virtual ~Observer() = default;
};

// 主题类，维护观察者并通知他们事件的发生
class Subject {
    std::vector<Observer*> observers;  // 观察者列表

public:
    // 通知所有观察者
    void notify(Event* event) {
        for (auto& observer : observers) {
            observer->update(event);
        }
    }

    // 添加观察者
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

    // 移除观察者
    void detach(Observer* observer) {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }
};

// 具体观察者类，负责接收事件并输出信息
class ConcreteObserver : public Observer {
public:
    void update(Event* event) override {
        std::cout << "Received event from source: " << event->source 
                  << " with type: " << event->type << std::endl;
    }
};

// 事件总线类，处理所有事件的分派和订阅
class EventBus {
    std::map<std::string, std::vector<std::function<void(Event*)>>> listeners;  // 事件类型与处理函数映射表

public:
    // 订阅某种类型的事件
    void subscribe(const std::string& eventType, std::function<void(Event*)> listener) {
        listeners[eventType].push_back(listener);
    }

    // 发布事件，调用所有相关处理函数
    void publish(Event* event) {
        auto& handlers = listeners[event->type];
        for (auto& handler : handlers) {
            handler(event);  // 依次调用每个处理函数
        }
    }
};

// 测试主函数
int main() {
    // 创建主题和观察者
    Subject subject;
    ConcreteObserver observer1;
    ConcreteObserver observer2;

    // 将观察者附加到主题
    subject.attach(&observer1);
    subject.attach(&observer2);

    // 创建一个事件源对象
    int eventSource = 42;

    // 发送事件，来源是 eventSource，类型是 "EventTypeA"
    Event eventA("EventTypeA", &eventSource);
    subject.notify(&eventA);

    // 使用事件总线
    EventBus bus;
    bus.subscribe("EventTypeB", [](Event* event) {
        std::cout << "EventTypeB received from source: " << event->source << std::endl;
    });

    // 发布事件，模拟事件来源是 eventSource，类型为 "EventTypeB"
    Event eventB("EventTypeB", &eventSource);
    bus.publish(&eventB);

    return 0;
}
